1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.collect;
18
19 import com.google.common.annotations.GwtCompatible;
20 import com.google.common.base.Function;
21 import com.google.common.base.Functions;
22 import com.google.common.collect.testing.MapInterfaceTest;
23
24 import java.util.Collection;
25 import java.util.Iterator;
26 import java.util.Map;
27 import java.util.Set;
28
29 import javax.annotation.Nullable;
30
31
32
33
34
35
36 @GwtCompatible
37 public class MapsTransformValuesTest extends MapInterfaceTest<String, String> {
38
39
40
41
42
43 protected MapsTransformValuesTest(
44 boolean allowsNullKeys,
45 boolean allowsNullValues,
46 boolean supportsPut,
47 boolean supportsRemove,
48 boolean supportsClear) {
49 super(allowsNullKeys, allowsNullValues, supportsPut, supportsRemove,
50 supportsClear, supportsRemove);
51 }
52
53 public MapsTransformValuesTest() {
54 super(false, true, false, true, true);
55 }
56
57 protected Map<String, String> makeEmptyMap() {
58 return Maps.transformValues(Maps.<String, String>newHashMap(),
59 Functions.<String>identity());
60 }
61
62 @Override
63 protected Map<String, String> makePopulatedMap() {
64 Map<String, Integer> underlying = Maps.newHashMap();
65 underlying.put("a", 1);
66 underlying.put("b", 2);
67 underlying.put("c", 3);
68 return Maps.transformValues(underlying, Functions.toStringFunction());
69 }
70
71 @Override protected String getKeyNotInPopulatedMap()
72 throws UnsupportedOperationException {
73 return "z";
74 }
75
76 @Override protected String getValueNotInPopulatedMap()
77 throws UnsupportedOperationException {
78 return "26";
79 }
80
81
82 private void assertMapsEqual(Map<?, ?> expected, Map<?, ?> map) {
83 assertEquals(expected, map);
84 assertEquals(expected.hashCode(), map.hashCode());
85 assertEquals(expected.entrySet(), map.entrySet());
86
87
88
89 Collection<?> expectedValues = expected.values();
90 Collection<?> mapValues = map.values();
91 assertEquals(expectedValues.size(), mapValues.size());
92 assertTrue(expectedValues.containsAll(mapValues));
93 assertTrue(mapValues.containsAll(expectedValues));
94 }
95
96 public void testTransformEmptyMapEquality() {
97 Map<String, String> map = Maps.transformValues(
98 ImmutableMap.<String, Integer>of(), Functions.toStringFunction());
99 assertMapsEqual(Maps.newHashMap(), map);
100 }
101
102 public void testTransformSingletonMapEquality() {
103 Map<String, String> map = Maps.transformValues(
104 ImmutableMap.of("a", 1), Functions.toStringFunction());
105 Map<String, String> expected = ImmutableMap.of("a", "1");
106 assertMapsEqual(expected, map);
107 assertEquals(expected.get("a"), map.get("a"));
108 }
109
110 public void testTransformIdentityFunctionEquality() {
111 Map<String, Integer> underlying = ImmutableMap.of("a", 1);
112 Map<String, Integer> map = Maps.transformValues(
113 underlying, Functions.<Integer>identity());
114 assertMapsEqual(underlying, map);
115 }
116
117 public void testTransformPutEntryIsUnsupported() {
118 Map<String, String> map = Maps.transformValues(
119 ImmutableMap.of("a", 1), Functions.toStringFunction());
120 try {
121 map.put("b", "2");
122 fail();
123 } catch (UnsupportedOperationException expected) {
124 }
125
126 try {
127 map.putAll(ImmutableMap.of("b", "2"));
128 fail();
129 } catch (UnsupportedOperationException expected) {
130 }
131
132 try {
133 map.entrySet().iterator().next().setValue("one");
134 fail();
135 } catch (UnsupportedOperationException expected) {
136 }
137 }
138
139 public void testTransformRemoveEntry() {
140 Map<String, Integer> underlying = Maps.newHashMap();
141 underlying.put("a", 1);
142 Map<String, String> map
143 = Maps.transformValues(underlying, Functions.toStringFunction());
144 assertEquals("1", map.remove("a"));
145 assertNull(map.remove("b"));
146 }
147
148 public void testTransformEqualityOfMapsWithNullValues() {
149 Map<String, String> underlying = Maps.newHashMap();
150 underlying.put("a", null);
151 underlying.put("b", "");
152
153 Map<String, Boolean> map = Maps.transformValues(underlying,
154 new Function<String, Boolean>() {
155 @Override
156 public Boolean apply(@Nullable String from) {
157 return from == null;
158 }
159 }
160 );
161 Map<String, Boolean> expected = ImmutableMap.of("a", true, "b", false);
162 assertMapsEqual(expected, map);
163 assertEquals(expected.get("a"), map.get("a"));
164 assertEquals(expected.containsKey("a"), map.containsKey("a"));
165 assertEquals(expected.get("b"), map.get("b"));
166 assertEquals(expected.containsKey("b"), map.containsKey("b"));
167 assertEquals(expected.get("c"), map.get("c"));
168 assertEquals(expected.containsKey("c"), map.containsKey("c"));
169 }
170
171 public void testTransformReflectsUnderlyingMap() {
172 Map<String, Integer> underlying = Maps.newHashMap();
173 underlying.put("a", 1);
174 underlying.put("b", 2);
175 underlying.put("c", 3);
176 Map<String, String> map
177 = Maps.transformValues(underlying, Functions.toStringFunction());
178 assertEquals(underlying.size(), map.size());
179
180 underlying.put("d", 4);
181 assertEquals(underlying.size(), map.size());
182 assertEquals("4", map.get("d"));
183
184 underlying.remove("c");
185 assertEquals(underlying.size(), map.size());
186 assertFalse(map.containsKey("c"));
187
188 underlying.clear();
189 assertEquals(underlying.size(), map.size());
190 }
191
192 public void testTransformChangesAreReflectedInUnderlyingMap() {
193 Map<String, Integer> underlying = Maps.newLinkedHashMap();
194 underlying.put("a", 1);
195 underlying.put("b", 2);
196 underlying.put("c", 3);
197 underlying.put("d", 4);
198 underlying.put("e", 5);
199 underlying.put("f", 6);
200 underlying.put("g", 7);
201 Map<String, String> map
202 = Maps.transformValues(underlying, Functions.toStringFunction());
203
204 map.remove("a");
205 assertFalse(underlying.containsKey("a"));
206
207 Set<String> keys = map.keySet();
208 keys.remove("b");
209 assertFalse(underlying.containsKey("b"));
210
211 Iterator<String> keyIterator = keys.iterator();
212 keyIterator.next();
213 keyIterator.remove();
214 assertFalse(underlying.containsKey("c"));
215
216 Collection<String> values = map.values();
217 values.remove("4");
218 assertFalse(underlying.containsKey("d"));
219
220 Iterator<String> valueIterator = values.iterator();
221 valueIterator.next();
222 valueIterator.remove();
223 assertFalse(underlying.containsKey("e"));
224
225 Set<Map.Entry<String, String>> entries = map.entrySet();
226 Map.Entry<String, String> firstEntry = entries.iterator().next();
227 entries.remove(firstEntry);
228 assertFalse(underlying.containsKey("f"));
229
230 Iterator<Map.Entry<String, String>> entryIterator = entries.iterator();
231 entryIterator.next();
232 entryIterator.remove();
233 assertFalse(underlying.containsKey("g"));
234
235 assertTrue(underlying.isEmpty());
236 assertTrue(map.isEmpty());
237 assertTrue(keys.isEmpty());
238 assertTrue(values.isEmpty());
239 assertTrue(entries.isEmpty());
240 }
241
242 public void testTransformEquals() {
243 Map<String, Integer> underlying = ImmutableMap.of("a", 0, "b", 1, "c", 2);
244 Map<String, Integer> expected
245 = Maps.transformValues(underlying, Functions.<Integer>identity());
246
247 assertMapsEqual(expected, expected);
248
249 Map<String, Integer> equalToUnderlying = Maps.newTreeMap();
250 equalToUnderlying.putAll(underlying);
251 Map<String, Integer> map = Maps.transformValues(
252 equalToUnderlying, Functions.<Integer>identity());
253 assertMapsEqual(expected, map);
254
255 map = Maps.transformValues(ImmutableMap.of("a", 1, "b", 2, "c", 3),
256 new Function<Integer, Integer>() {
257 @Override
258 public Integer apply(Integer from) {
259 return from - 1;
260 }
261 }
262 );
263 assertMapsEqual(expected, map);
264 }
265
266 public void testTransformEntrySetContains() {
267 Map<String, Boolean> underlying = Maps.newHashMap();
268 underlying.put("a", null);
269 underlying.put("b", true);
270 underlying.put(null, true);
271
272 Map<String, Boolean> map = Maps.transformValues(
273 underlying, new Function<Boolean, Boolean>() {
274 @Override
275 public Boolean apply(@Nullable Boolean from) {
276 return (from == null) ? true : null;
277 }
278 }
279 );
280
281 Set<Map.Entry<String, Boolean>> entries = map.entrySet();
282 assertTrue(entries.contains(Maps.immutableEntry("a", true)));
283 assertTrue(entries.contains(Maps.immutableEntry("b", (Boolean) null)));
284 assertTrue(entries.contains(
285 Maps.immutableEntry((String) null, (Boolean) null)));
286
287 assertFalse(entries.contains(Maps.immutableEntry("c", (Boolean) null)));
288 assertFalse(entries.contains(Maps.immutableEntry((String) null, true)));
289 }
290
291 @Override public void testKeySetRemoveAllNullFromEmpty() {
292 try {
293 super.testKeySetRemoveAllNullFromEmpty();
294 } catch (RuntimeException tolerated) {
295
296 }
297 }
298
299 @Override public void testEntrySetRemoveAllNullFromEmpty() {
300 try {
301 super.testEntrySetRemoveAllNullFromEmpty();
302 } catch (RuntimeException tolerated) {
303
304 }
305 }
306 }